home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / mach / ds5000.md / machAsmDefs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  6.2 KB  |  227 lines
  1. /*
  2.  * machAsmDefs.h --
  3.  *
  4.  *    Macros used when writing assembler programs.
  5.  *
  6.  *    Copyright (C) 1989 Digital Equipment Corporation.
  7.  *    Permission to use, copy, modify, and distribute this software and
  8.  *    its documentation for any purpose and without fee is hereby granted,
  9.  *    provided that the above copyright notice appears in all copies.
  10.  *    Digital Equipment Corporation makes no representations about the
  11.  *    suitability of this software for any purpose.  It is provided "as is"
  12.  *    without express or implied warranty.
  13.  *
  14.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/mach/ds5000.md/machAsmDefs.h,v 9.1 91/03/30 16:59:42 jhh Exp $ SPRITE (DECWRL)
  15.  */
  16.  
  17. #ifndef _MACHASMDEFS
  18. #define _MACHASMDEFS
  19.  
  20. #include "machConst.h"
  21.  
  22. /*
  23.  * LEAF(x)
  24.  *
  25.  *    Declare a leaf routine.
  26.  */
  27. #define LEAF(x) \
  28.     .globl x; \
  29.     .ent x, 0; \
  30. x: ; \
  31.     .frame sp, 0, ra
  32.  
  33. /*
  34.  * NON_LEAF(x)
  35.  *
  36.  *    Declare a non-leaf routine (a routine that makes other C calls).
  37.  */
  38. #define NON_LEAF(x, fsize, retpc) \
  39.     .globl x; \
  40.     .ent x, 0; \
  41. x: ; \
  42.     .frame sp, fsize, retpc
  43.  
  44. /*
  45.  * END(x)
  46.  *
  47.  *    Mark end of a procedure.
  48.  */
  49. #define END(x) \
  50.     .end x
  51.  
  52. /*
  53.  * SAVE_REGS(baseReg, offset)
  54.  *
  55.  *    Save all of the registers except for the kernel temporaries in the
  56.  *    area pointed to by baseReg + offset.
  57.  */
  58. #define SAVE_REGS(baseReg, offset) \
  59.     sw        AT, (offset) +  4(baseReg); \
  60.     sw        v0, (offset) +  8(baseReg); \
  61.     sw        v1, (offset) +  12(baseReg); \
  62.     sw        a0, (offset) +  16(baseReg); \
  63.     sw        a1, (offset) +  20(baseReg); \
  64.     sw        a2, (offset) +  24(baseReg); \
  65.     sw        a3, (offset) +  28(baseReg); \
  66.     sw        t0, (offset) +  32(baseReg); \
  67.     sw        t1, (offset) +  36(baseReg); \
  68.     sw        t2, (offset) +  40(baseReg); \
  69.     sw        t3, (offset) +  44(baseReg); \
  70.     sw        t4, (offset) +  48(baseReg); \
  71.     sw        t5, (offset) +  52(baseReg); \
  72.     sw        t6, (offset) +  56(baseReg); \
  73.     sw        t7, (offset) +  60(baseReg); \
  74.     sw        s0, (offset) +  64(baseReg); \
  75.     sw        s1, (offset) +  68(baseReg); \
  76.     sw        s2, (offset) +  72(baseReg); \
  77.     sw        s3, (offset) +  76(baseReg); \
  78.     sw        s4, (offset) +  80(baseReg); \
  79.     sw        s5, (offset) +  84(baseReg); \
  80.     sw        s6, (offset) +  88(baseReg); \
  81.     sw        s7, (offset) +  92(baseReg); \
  82.     sw        t8, (offset) +  96(baseReg); \
  83.     sw        t9, (offset) +  100(baseReg); \
  84.     sw        s8, (offset) +  120(baseReg); \
  85.     sw        ra, (offset) +  124(baseReg)
  86.  
  87. /*
  88.  * RESTORE_REGS(baseReg, offset)
  89.  *
  90.  *    Restore all of the registers except for the kernel's temporaries
  91.  *    to the area pointed to by baseReg + offset.
  92.  */
  93. #define RESTORE_REGS(baseReg, offset) \
  94.     lw        AT, (offset) +  4(baseReg); \
  95.     lw        v0, (offset) +  8(baseReg); \
  96.     lw        v1, (offset) +  12(baseReg); \
  97.     lw        a0, (offset) +  16(baseReg); \
  98.     lw        a1, (offset) +  20(baseReg); \
  99.     lw        a2, (offset) +  24(baseReg); \
  100.     lw        a3, (offset) +  28(baseReg); \
  101.     lw        t0, (offset) +  32(baseReg); \
  102.     lw        t1, (offset) +  36(baseReg); \
  103.     lw        t2, (offset) +  40(baseReg); \
  104.     lw        t3, (offset) +  44(baseReg); \
  105.     lw        t4, (offset) +  48(baseReg); \
  106.     lw        t5, (offset) +  52(baseReg); \
  107.     lw        t6, (offset) +  56(baseReg); \
  108.     lw        t7, (offset) +  60(baseReg); \
  109.     lw        s0, (offset) +  64(baseReg); \
  110.     lw        s1, (offset) +  68(baseReg); \
  111.     lw        s2, (offset) +  72(baseReg); \
  112.     lw        s3, (offset) +  76(baseReg); \
  113.     lw        s4, (offset) +  80(baseReg); \
  114.     lw        s5, (offset) +  84(baseReg); \
  115.     lw        s6, (offset) +  88(baseReg); \
  116.     lw        s7, (offset) +  92(baseReg); \
  117.     lw        t8, (offset) +  96(baseReg); \
  118.     lw        t9, (offset) +  100(baseReg); \
  119.     lw        gp, (offset) +  112(baseReg); \
  120.     lw        sp, (offset) +  116(baseReg); \
  121.     lw        s8, (offset) +  120(baseReg); \
  122.     lw        ra, (offset) +  124(baseReg)
  123.  
  124. /*
  125.  * SAVE_KERNEL_REGS()
  126.  *
  127.  *    Save all of the kernel's relevant registers onto the stack.
  128.  */
  129. #define SAVE_KERNEL_REGS(offset) \
  130.     sw        AT,(offset) + 0(sp); \
  131.     sw        v0,(offset) + 4(sp); \
  132.     sw        v1,(offset) + 8(sp); \
  133.     sw        a0,(offset) + 12(sp); \
  134.     sw        a1,(offset) + 16(sp); \
  135.     sw        a2,(offset) + 20(sp); \
  136.     sw        a3,(offset) + 24(sp); \
  137.     sw        t0,(offset) + 28(sp); \
  138.     sw        t1,(offset) + 32(sp); \
  139.     sw        t2,(offset) + 36(sp); \
  140.     sw        t3,(offset) + 40(sp); \
  141.     sw        t4,(offset) + 44(sp); \
  142.     sw        t5,(offset) + 48(sp); \
  143.     sw        t6,(offset) + 52(sp); \
  144.     sw        t7,(offset) + 56(sp); \
  145.     sw        s0,(offset) + 60(sp); \
  146.     sw        s1,(offset) + 64(sp); \
  147.     sw        s2,(offset) + 68(sp); \
  148.     sw        s3,(offset) + 72(sp); \
  149.     sw        s4,(offset) + 76(sp); \
  150.     sw        s5,(offset) + 80(sp); \
  151.     sw        s6,(offset) + 84(sp); \
  152.     sw        s7,(offset) + 88(sp); \
  153.     sw        t8,(offset) + 92(sp); \
  154.     sw        t9,(offset) + 96(sp); \
  155.     sw        gp,(offset) + 100(sp); \
  156.     sw        s8,(offset) + 104(sp); \
  157.     sw        ra,(offset) + 108(sp)
  158.  
  159. /*
  160.  * RESTORE_KERNEL_REGS()
  161.  *
  162.  *    Restore all of the kernel's relevant registers from the stack.
  163.  */
  164. #define RESTORE_KERNEL_REGS(offset) \
  165.     lw        AT,(offset) + 0(sp); \
  166.     lw        v0,(offset) + 4(sp); \
  167.     lw        v1,(offset) + 8(sp); \
  168.     lw        a0,(offset) + 12(sp); \
  169.     lw        a1,(offset) + 16(sp); \
  170.     lw        a2,(offset) + 20(sp); \
  171.     lw        a3,(offset) + 24(sp); \
  172.     lw        t0,(offset) + 28(sp); \
  173.     lw        t1,(offset) + 32(sp); \
  174.     lw        t2,(offset) + 36(sp); \
  175.     lw        t3,(offset) + 40(sp); \
  176.     lw        t4,(offset) + 44(sp); \
  177.     lw        t5,(offset) + 48(sp); \
  178.     lw        t6,(offset) + 52(sp); \
  179.     lw        t7,(offset) + 56(sp); \
  180.     lw        s0,(offset) + 60(sp); \
  181.     lw        s1,(offset) + 64(sp); \
  182.     lw        s2,(offset) + 68(sp); \
  183.     lw        s3,(offset) + 72(sp); \
  184.     lw        s4,(offset) + 76(sp); \
  185.     lw        s5,(offset) + 80(sp); \
  186.     lw        s6,(offset) + 84(sp); \
  187.     lw        s7,(offset) + 88(sp); \
  188.     lw        t8,(offset) + 92(sp); \
  189.     lw        t9,(offset) + 96(sp); \
  190.     lw        gp,(offset) + 100(sp); \
  191.     lw        s8,(offset) + 104(sp); \
  192.     lw        ra,(offset) + 108(sp)
  193.  
  194. #define SAVED_REG_SIZE        112
  195. #define STAND_FRAME_SIZE    24
  196. #define STAND_RA_OFFSET        20
  197.  
  198. #define MACH_MON_JUMP_TABLE_ADDR    0xBFC00000
  199. #define MACH_MON_FUNC_ADDR(funcNum)    (MACH_MON_JUMP_TABLE_ADDR+((funcNum)*8))
  200. #define MACH_MON_PRINTF        MACH_MON_FUNC_ADDR(17)
  201.  
  202. /*
  203.  * Macros to panic and printf from assembly language.
  204.  */
  205. #define PANIC(msg) \
  206.     la    a0, 9f; \
  207.     jal    panic; \
  208.     MSG(msg)
  209.  
  210. #define    PRINTF(msg) \
  211.     la    a0,9f; \
  212.     jal    printf; \
  213.     MSG(msg)
  214.  
  215. #define    MON_PRINTF(msg) \
  216.     la    a0,9f; \
  217.     la    t0, MACH_MON_PRINTF; \
  218.     jal    t0; \
  219.     MSG(msg)
  220.  
  221. #define    MSG(msg) \
  222.     .rdata; \
  223. 9:    .asciiz    msg; \
  224.     .text
  225.  
  226. #endif /* _MACHASMDEFS */
  227.